.TH std::fpclassify 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::fpclassify \- std::fpclassify

.SH Synopsis
   Defined in header <cmath>
   int fpclassify( float num );
                                                                \fI(since C++11)\fP
   int fpclassify( double num );                                (until C++23)

   int fpclassify( long double num );
   constexpr int fpclassify( /* floating-point-type */  \fB(1)\fP     (since C++23)
   num );
   Additional overloads
   Defined in header <cmath>
   template< class Integer >                                (A) \fI(since C++11)\fP
   int fpclassify( Integer num );                               (constexpr since C++23)

   1) Categorizes floating point value num into the following categories: zero,
   subnormal, normal, infinite, NAN, or implementation-defined category.
   The library provides overloads of std::fpclassify for all cv-unqualified
   floating-point types as the type of the parameter num.
   (since C++23)
   A) Additional overloads are provided for all integer types, which are treated as
   double.

.SH Parameters

   num - floating-point or integer value

.SH Return value

   one of FP_INFINITE, FP_NAN, FP_NORMAL, FP_SUBNORMAL, FP_ZERO or
   implementation-defined type, specifying the category of num.

.SH Notes

   The additional overloads are not required to be provided exactly as (A). They only
   need to be sufficient to ensure that for their argument num of integer type,
   std::fpclassify(num) has the same effect as
   std::fpclassify(static_cast<double>(num)).

.SH Example


// Run this code

 #include <cfloat>
 #include <cmath>
 #include <iostream>

 auto show_classification(double x)
 {
     switch (std::fpclassify(x))
     {
         case FP_INFINITE:
             return "Inf";
         case FP_NAN:
             return "NaN";
         case FP_NORMAL:
             return "normal";
         case FP_SUBNORMAL:
             return "subnormal";
         case FP_ZERO:
             return "zero";
         default:
             return "unknown";
     }
 }

 int main()
 {
     std::cout << "1.0/0.0 is " << show_classification(1 / 0.0) << '\\n'
               << "0.0/0.0 is " << show_classification(0.0 / 0.0) << '\\n'
               << "DBL_MIN/2 is " << show_classification(DBL_MIN / 2) << '\\n'
               << "-0.0 is " << show_classification(-0.0) << '\\n'
               << "1.0 is " << show_classification(1.0) << '\\n';
 }

.SH Output:

 1.0/0.0 is Inf
 0.0/0.0 is NaN
 DBL_MIN/2 is subnormal
 -0.0 is zero
 1.0 is normal

.SH See also

   isfinite       checks if the given number has finite value
   \fI(C++11)\fP        \fI(function)\fP
   isinf          checks if the given number is infinite
   \fI(C++11)\fP        \fI(function)\fP
   isnan          checks if the given number is NaN
   \fI(C++11)\fP        \fI(function)\fP
   isnormal       checks if the given number is normal
   \fI(C++11)\fP        \fI(function)\fP
                  provides an interface to query properties of all fundamental numeric
   numeric_limits types
                  \fI(class template)\fP
   C documentation for
   fpclassify
